{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 循环神经网络"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 循环神经网络模块\n",
    "RNN无法有效应对长时依赖问题，时间跨度较大，所以会丢失较前的信息，LSTM (Long Short Term Memory Networks)和GRU (Gated Recurrent Unit)可以一定程度上解决长时依赖问题，但后来提出的注意力attention机制会更加有效"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 原始RNN\n",
    "网络有两个输入：当前时刻$t$的输入$x_t$和$t-1$时刻的隐藏状态$h_{t-1}$\n",
    "- $x_t$的维度：**(seq, batch, feature)**，分别表示序列长度、批量和输入特征维度\n",
    "- $h_{t-1}$的维度：**(layers*direction, batch, hidden)**，分别表示层数乘方向(单向为1，双向为2)，批量和输出维度\n",
    "\n",
    "网络有两个输出：当前时刻$t$的输出$output$和隐藏状态$h_t$\n",
    "- $output$的维度：**(seq, batch, hidden*direction)**，分别表示序列长度，批量和输出维度乘方向(单向为1，双向为2)\n",
    "- $h_t$的维度：**(layers*direction, batch, hidden)**，分别表示层数乘方向(单向为1，双向为2)，批量和输出维度\n",
    "\n",
    "**注意**：$h_{t-1}$和 $h_t$的维度是一致的；在网络初始化时有隐藏状态$h_0$，可以自己指定，如果不指定则默认为0；在单向的RNN中每层只有一个记忆单元，双向的有两个\n",
    "\n",
    "RNN的内部网络计算公式：\n",
    "$$h_t=tanh(w_{ih}*x_t+b_{ih}+w_{hh}*h_{t-1}+b_{hh})$$\n",
    "\n",
    "在PyTorch中使用`nn.RNN(*args, **kargs)`定义，根据参数的定义形式使用`nn.RNN(input_size=20, hidden_size=50, num_layers=2)`和`nn.RNN(20, 50, 2)`定义的结果一致，参数列表如下：\n",
    "\n",
    "|参数|功能|\n",
    "|-|-|\n",
    "|input_size|输入$x_t$的特征维度|\n",
    "|hidden_size|输出(隐藏状态)$h_t$的特征维度|\n",
    "|num_layers|网络层数，默认为**1**|\n",
    "|nonlinearity|非线性激活函数，默认tanh，可选relu|\n",
    "|bias|是否使用偏置，默认使用**True**|\n",
    "|batch_first|决定网络输入维度的顺序，默认顺序为<br>**(seq, batch, feature)**,如果设置为True，<br>顺序变为(batch, seq, feature)|\n",
    "|dropout|参数接收0~1的数值，在除最后一层外<br>的其他层加dropout层，默认为**0**|\n",
    "|bidirectional|设置为True表示双向循环神经网络，<br>默认**False**|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 注意：0.4版本开始的新规范，Variable和tensor合并后程序有所不同\n",
    "参考：[Variable和Tensor合并后，PyTorch的代码要怎么改](https://blog.csdn.net/dQCFKyQDXYm3F8rB0/article/details/80105285)\n",
    "从0.4版本开始程序框架如下：\n",
    "```python\n",
    "# torch.device object used throughout this script\n",
    "use_cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "model = MyRNN().to(device)\n",
    " \n",
    "# train\n",
    "total_loss = 0\n",
    "for inputs, target in train_loader:\n",
    "     inputs, target = inputs.to(device), target.to(device)\n",
    "     hidden = inputs.new_zeros(*h_shape) \n",
    "     # has the same device & dtype as `input`\n",
    "     ...  # get loss and optimize\n",
    "     total_loss += loss.item() # get Python number from 1-element Tensor\n",
    "\n",
    "# evaluate\n",
    "with torch.no_grad():          # operations inside don't track history\n",
    "     for inputs, target in test_loader:\n",
    "```\n",
    "\n",
    "其他修改部分：\n",
    "1. 使用`x.detach()`代替Variable中的`x.data`来修改数据，仅**原地**修改可改变原tensor\n",
    "2. 损失函数中使用`loss.item()`代替`loss.data[0]`来获取python数值\n",
    "3. 使用`tensor.type()`输出tensor的类型\n",
    "4. `torch.no_grad()`代替`volatile`标志位\n",
    "5. 可以创建零维向量，如`torch.tensor(2)`，更类似于`numpy.array()`函数\n",
    "```python\n",
    "print(torch.tensor(2))  # 只指定数据\n",
    "print(torch.Tensor(2))  # 既可以指定数据，也可以指定维度来随机数据\n",
    "# tensor(2)\n",
    "# tensor(1.00000e-45 *\n",
    "#      [ 1.4013,  0.0000])\n",
    "```\n",
    "\n",
    "注意：\n",
    "\n",
    "\n",
    "- 训练网络的时候把模型和数据都放到GPU上，测试的时候放到CPU上，因为cuda的变量无法直接转变为numpy的变量，测试会涉及到可视化等分析步骤，用numpy数据更佳\n",
    "- `model.to(device)`的方法不依赖设备更加通用，`model.cpu()`或`model.cuda()`转换模型的计算方式(变量同理)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.4.1'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "from torch import nn, optim\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.utils.model_zoo as model_zoo\n",
    "from torchvision import transforms, datasets, models\n",
    "\n",
    "# 优先使用GPU\n",
    "use_cuda = torch.cuda.is_available()\n",
    "device = torch.device('cuda' if use_cuda else 'cpu')\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.weight_ih的两个权重: torch.Size([50, 20]) torch.Size([50, 50])\n",
      "  bias_ih的权重: torch.Size([50]) torch.Size([50])\n",
      "2.weight_hh的两个权重: torch.Size([50, 50]) torch.Size([50, 50])\n",
      "  bias_hh的权重: torch.Size([50]) torch.Size([50])\n"
     ]
    }
   ],
   "source": [
    "basic_rnn = nn.RNN(input_size=20, hidden_size=50, num_layers=2)\n",
    "print('1.weight_ih的两个权重:', basic_rnn.weight_ih_l0.shape, basic_rnn.weight_ih_l1.shape)\n",
    "print('  bias_ih的权重:', basic_rnn.bias_ih_l0.shape, basic_rnn.bias_ih_l1.shape)\n",
    "print('2.weight_hh的两个权重:', basic_rnn.weight_hh_l0.shape, basic_rnn.weight_hh_l1.shape)\n",
    "print('  bias_hh的权重:', basic_rnn.bias_hh_l0.shape, basic_rnn.bias_hh_l1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.RNN的输出output: torch.Size([100, 32, 50])\n",
      "2.RNN的输出隐层状态: torch.Size([2, 32, 50])\n"
     ]
    }
   ],
   "source": [
    "# 随机化初始输入xt和隐藏状态h0\n",
    "toy_input = torch.randn([100, 32, 20])            # [seq, batch, feature] \n",
    "h_0 = torch.randn([2, 32, 50])                    # [layers*direction, batch, hidden_size]\n",
    "toy_output, h_n = basic_rnn(toy_input, h_0)       # 注意h_0初始状态!!!\n",
    "print('1.RNN的输出output:', toy_output.shape)     # [seq, batch, hidden_size*direction] \n",
    "print('2.RNN的输出隐层状态:', h_n.shape)           # [layers*direction, batch, hidden_size]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "小结：\n",
    "- 在一层的RNN中，如果是非双向循环的网络，一般只有一个记忆单元，所以隐藏状态的第一维度都是1，双向的网络为2，不同的层有各自的记忆单元，所以隐藏状态$h_t$的第一维度为：**layers*direction**，双向网络direction为2，普通的为1\n",
    "- 下面程序用于显示进度，以后可能会用，注意print函数中设置`end='\\r'`可以覆盖原输出\n",
    "```python\n",
    "def show_progress():\n",
    "    process = '<' + '.'*25 + '>'\n",
    "    for i in range(1, 26):\n",
    "        time.sleep(0.5)\n",
    "        process= process.replace('.', '=', 1)\n",
    "        print(process, end='\\r')\n",
    "    print('\\nfinished!')\n",
    "# 输出\n",
    "# <=========================>\n",
    "# finished!\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([5., 9.]) tensor([5., 9.])\n"
     ]
    }
   ],
   "source": [
    "# pytorch中的detach用法\n",
    "t1 = torch.FloatTensor([1., 2.])\n",
    "v1 = Variable(t1)\n",
    "t2 = torch.FloatTensor([2., 3.])\n",
    "v2 = Variable(t2)\n",
    "v3 = v1 + v2\n",
    "v3_detached = v3.detach()      # 只能原地修改\n",
    "v3_detached.data.add_(t1*2)    # 修改了 v3_detached Variable中 tensor 的值\n",
    "print(v3, v3_detached)         # v3 中tensor 的值也会改变"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 LSTM与GRU\n",
    "本质上与RNN一样，只是内部计算更复杂，参数更多\n",
    "- LSTM做了4次类似标准RNN的运算，所以参数是标准RNN的4倍，隐藏状态为$h_0$和$c_0$，维度均是**(layers*direction, batch, hidden_size)**，direction：单向为1，双向为2\n",
    "- GRU参数是标准RNN的3倍，隐藏状态只有$h_0$，维度同上\n",
    "- LSTM与GRU的定义方法基本与标准RNN的一样，但无nonlinearity参数，其他可参考标准RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.weight_ih的两个权重: torch.Size([200, 20]) torch.Size([200, 50])\n",
      "  bias_ih的权重: torch.Size([200]) torch.Size([200])\n",
      "2.weight_hh的两个权重: torch.Size([200, 50]) torch.Size([200, 50])\n",
      "  bias_hh的权重: torch.Size([200]) torch.Size([200])\n"
     ]
    }
   ],
   "source": [
    "# 1. 定义lstm\n",
    "# 参数维度4翻倍：[output_size*4, input_size]\n",
    "lstm = nn.LSTM(input_size=20, hidden_size=50, num_layers=2)\n",
    "print('1.weight_ih的两个权重:', lstm.weight_ih_l0.shape, lstm.weight_ih_l1.shape)\n",
    "print('  bias_ih的权重:', lstm.bias_ih_l0.shape, lstm.bias_ih_l1.shape)\n",
    "print('2.weight_hh的两个权重:', lstm.weight_hh_l0.shape, lstm.weight_hh_l1.shape)\n",
    "print('  bias_hh的权重:', lstm.bias_hh_l0.shape, lstm.bias_hh_l1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([100, 32, 50])\n",
      "torch.Size([2, 32, 50])\n",
      "torch.Size([2, 32, 50])\n"
     ]
    }
   ],
   "source": [
    "toy_input = torch.randn([100, 32, 20])            # [seq, batch, feature] \n",
    "lstm_out, (h_n, c_n) = lstm(toy_input)\n",
    "print(lstm_out.shape)        # [seq, batch, hidden*direction]\n",
    "print(h_n.shape)             # [layers*direction, batch, hidden]\n",
    "print(c_n.shape)             # [layers*direction, batch, hidden]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.weight_ih的两个权重: torch.Size([150, 20]) torch.Size([150, 50])\n",
      "  bias_ih的权重: torch.Size([150]) torch.Size([150])\n",
      "2.weight_hh的两个权重: torch.Size([150, 50]) torch.Size([150, 50])\n",
      "  bias_hh的权重: torch.Size([150]) torch.Size([150])\n"
     ]
    }
   ],
   "source": [
    "# 2. 定义GRU\n",
    "gru = nn.GRU(input_size=20, hidden_size=50, num_layers=2)\n",
    "print('1.weight_ih的两个权重:', gru.weight_ih_l0.shape, gru.weight_ih_l1.shape)\n",
    "print('  bias_ih的权重:', gru.bias_ih_l0.shape, gru.bias_ih_l1.shape)\n",
    "print('2.weight_hh的两个权重:', gru.weight_hh_l0.shape, gru.weight_hh_l1.shape)\n",
    "print('  bias_hh的权重:', gru.bias_hh_l0.shape, gru.bias_hh_l1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([100, 32, 50])\n",
      "torch.Size([2, 32, 50])\n"
     ]
    }
   ],
   "source": [
    "gru_out, h_n = gru(toy_input)\n",
    "print(gru_out.shape)         # [seq, batch, hidden*direction]\n",
    "print(h_n.shape)             # [layers*direction, batch, hidden]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "小结:\n",
    "- nn.RNN、nn.LSTM和nn.GRU定义的是完整序列的网络，而RNNCell、LSTMCell和GRUCell定义单步的网络，即只是序列中的一步，循环神经网络的一个循环\n",
    "- batch_first的参数只对输入和输出的batch和seq的顺序有影响，该参数为True，$x_t$维度变为**(batch,seq,feature)**，output的维度变为**(batch,seq,hidden*direction)**，但$h_{t-1}$和$h_{t}$的维度不会变，仍旧是**(layers*direction,batch,hidden)**，`output, h_n = basic_rnn(toy_input, h_0)`语句得到的隐藏状态都是整个序列最后时刻的隐藏状态，所以没有seq维度\n",
    "- 使用语句`lstm_out,(h_n, c_n)=lstm(toy_input, (h0,c0))`来为lstm添加输入状态，h0和c0的维度一致，都是**(layers*direction,batch,hidden)**，如果不写，默认全0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 循环神经网络实例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 图像分类\n",
    "这里使用MNIST数据集，该数据集中图像是28*28的，可以将图像看作长为28的序列，序列中每个元素特征维度为28，将图像序列化后可以用RNN来处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.导入数据\n",
    "data_tf =transforms.Compose([\n",
    "    transforms.ToTensor(),                   # 将图像转换为[0~1]的tensor\n",
    "    transforms.Normalize([0.5], [0.5])       # 标准化到[-1,1]\n",
    "])\n",
    "# 导入MNIST数据集\n",
    "train_datasets = datasets.MNIST(root='./data/MNIST', train=True, transform=data_tf, download=False)\n",
    "test_datasets = datasets.MNIST(root='./data/MNIST', train=False, transform=data_tf)\n",
    "\n",
    "# [b,28,28] 可以看作 [batch, seq, feature]的序列化数据\n",
    "train_loader = DataLoader(train_datasets, batch_size=64, shuffle=True, num_workers=4)\n",
    "test_loader = DataLoader(test_datasets, batch_size=64, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ff8b226208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 显示数据\n",
    "def show():\n",
    "    labels = test_datasets.test_labels.numpy()  # 没有经过transforms的数据\n",
    "    data = test_datasets.test_data.numpy()\n",
    "    # np.where获得结果:(array([1,...], dtype=int64), )，所以使用[0][index]获取元素\n",
    "    sample_index = [np.where(labels==i)[0][0] for i in range(10)]\n",
    "    sample_data = data[sample_index]\n",
    "    for i in range(10):\n",
    "        plt.subplot(2, 5, i+1)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(sample_data[i], cmap='gray')\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建序列化图像的生成器，为训练模型提供批次数据(该函数不是必须的)\n",
    "# [b,28,28] -> [b, seq, feature]\n",
    "def generator(batch_size=32, train=True, shuffle=True):\n",
    "    datasets = train_datasets if train else test_datasets\n",
    "    # 先生成批次的数据\n",
    "    loader = DataLoader(datasets, batch_size=batch_size, shuffle=shuffle, num_workers=4)\n",
    "    for data in loader:\n",
    "       yield data[0], data[1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.定义模型\n",
    "class RNN(nn.Module):\n",
    "    def __init__(self, in_dim, hidden_dim, n_layers, n_classes):\n",
    "        super().__init__() \n",
    "        self.n_layers = n_layers       # RNN层数\n",
    "        self.n_classes = n_classes     # 输出类别数\n",
    "        self.hidden_dim = hidden_dim   # 隐藏状态特征数\n",
    "        self.lstm = nn.LSTM(input_size=in_dim, hidden_size=hidden_dim, \n",
    "                            num_layers=n_layers, batch_first=True)\n",
    "        # batch_first 使输入为 [batch, seq, input_dim]\n",
    "        self.classifier = nn.Linear(hidden_dim, n_classes)   # 分类\n",
    "    def forward(self, x):\n",
    "        lstm_out, _ = self.lstm(x)     # 传入网络 get [batch,seq,hidden]\n",
    "        out = lstm_out[:, -1, :]       # 获取序列的最后输出 get [batch,hidden]\n",
    "        # 获取序列最后时间点的输出，seq和时间序列对应\n",
    "#         print(out.shape)             # get [batch, hidden]\n",
    "        out = self.classifier(out)     # get [batch, n_classes] \n",
    "#         print(out.shape)\n",
    "        return out   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.RNN"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 定义损失函数及优化函数\n",
    "rnn_model = RNN(28,256,2,10)           # 创建模型\n",
    "criterion = nn.CrossEntropyLoss()      # 用于标签不是one-hot的数据\n",
    "optimizer = optim.Adam(rnn_model.parameters(), lr=1e-2)\n",
    "type(rnn_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------\n",
      "Epoch 1\n",
      "Batches 0 loss 2.3216\n",
      "Batches 100 loss 1.1047\n",
      "Batches 200 loss 0.8123\n",
      "Batches 300 loss 0.5777\n",
      "Batches 400 loss 0.4368\n",
      "Batches 500 loss 0.6357\n",
      "Batches 600 loss 0.1623\n",
      "Batches 700 loss 0.1753\n",
      "Batches 800 loss 0.1736\n",
      "Batches 900 loss 0.2381\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\lib\\site-packages\\torch\\serialization.py:241: UserWarning: Couldn't retrieve source code for container of type RNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "# 3.训练模型\n",
    "batch_size = 32      # 定义batch_size\n",
    "epochs = 1           # 定义epoch最大次数\n",
    "max_batches = np.ceil(len(train_datasets) / batch_size)*epochs\n",
    "# print(max_batches)\n",
    "\n",
    "def train(model, batch_size, epochs, save_path='./model'):\n",
    "    num_batches = 0                                    # 记录batches的数目\n",
    "    train_loader = DataLoader(train_datasets, batch_size=batch_size, shuffle=True,\n",
    "                             num_workers=4) \n",
    "    model.to(device)\n",
    "    for epoch in range(epochs):\n",
    "        print('-'*20)\n",
    "        print('Epoch {}'.format(epoch+1))\n",
    "        for data in train_loader: \n",
    "            # 将变量及模型放到GPU上\n",
    "            x_train, y_train = data   # x维度 [b,1,28,28]\n",
    "            x_train = x_train[:,0]    # x维度 [b,28,28]\n",
    "            x_train, y_train = x_train.to(device), y_train.to(device)\n",
    "#             print(x_train.shape)\n",
    "            # forward + backward + optimizer    \n",
    "            out = model(x_train)                  # 计算输出\n",
    "            loss = criterion(out, y_train)        # 计算损失函数\n",
    "            print_loss = loss.item()\n",
    "            optimizer.zero_grad()                 # 梯度归零\n",
    "            loss.backward()                       # 反向传播\n",
    "            optimizer.step()                      # 更新参数\n",
    "#             print(num_batches)\n",
    "                        \n",
    "            if (num_batches) % 100 == 0:\n",
    "#                 print(type(model))\n",
    "                print('Batches {} loss {:.4f}'.format(num_batches, print_loss))\n",
    "            num_batches += 1\n",
    "            if num_batches == 1000:               # 为了快速验证程序，中断训练\n",
    "                break\n",
    "    # 存储路径        \n",
    "    save_path = os.path.join(save_path, 'rnn_{}.pth'.format(num_batches))   \n",
    "    torch.save(model, save_path)                #存储路径\n",
    "     \n",
    "train(rnn_model, batch_size, epochs)         # 训练网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 10 Test Loss: 0.325782, ACC: 0.875000\n",
      "Epoch: 20 Test Loss: 0.314867, ACC: 0.906250\n",
      "Epoch: 30 Test Loss: 0.760924, ACC: 0.812500\n",
      "Epoch: 40 Test Loss: 0.154022, ACC: 0.968750\n",
      "Epoch: 50 Test Loss: 0.392825, ACC: 0.812500\n",
      "Epoch: 60 Test Loss: 0.227158, ACC: 0.906250\n",
      "Epoch: 70 Test Loss: 0.136976, ACC: 0.937500\n",
      "Epoch: 80 Test Loss: 0.431785, ACC: 0.906250\n",
      "Epoch: 90 Test Loss: 0.406359, ACC: 0.875000\n",
      "Epoch: 100 Test Loss: 0.218097, ACC: 0.906250\n",
      "Epoch: 110 Test Loss: 0.335643, ACC: 0.906250\n",
      "Epoch: 120 Test Loss: 0.327196, ACC: 0.937500\n",
      "Epoch: 130 Test Loss: 0.266079, ACC: 0.906250\n",
      "Epoch: 140 Test Loss: 0.212897, ACC: 0.875000\n",
      "Epoch: 150 Test Loss: 0.058009, ACC: 1.000000\n",
      "Epoch: 160 Test Loss: 0.131273, ACC: 0.968750\n",
      "Epoch: 170 Test Loss: 0.025309, ACC: 1.000000\n",
      "Epoch: 180 Test Loss: 0.424163, ACC: 0.875000\n",
      "Epoch: 190 Test Loss: 0.420898, ACC: 0.843750\n",
      "Epoch: 200 Test Loss: 0.152244, ACC: 0.968750\n",
      "Epoch: 210 Test Loss: 0.032617, ACC: 1.000000\n",
      "Epoch: 220 Test Loss: 0.063072, ACC: 0.968750\n",
      "Epoch: 230 Test Loss: 0.135282, ACC: 0.968750\n",
      "Epoch: 240 Test Loss: 0.031490, ACC: 1.000000\n",
      "Epoch: 250 Test Loss: 0.074828, ACC: 1.000000\n",
      "Epoch: 260 Test Loss: 0.358458, ACC: 0.843750\n",
      "Epoch: 270 Test Loss: 0.217733, ACC: 0.968750\n",
      "Epoch: 280 Test Loss: 0.041948, ACC: 0.968750\n",
      "Epoch: 290 Test Loss: 0.082312, ACC: 0.968750\n",
      "Epoch: 300 Test Loss: 0.055577, ACC: 0.968750\n",
      "Epoch: 310 Test Loss: 0.290394, ACC: 0.906250\n",
      "----------Test Done!----------\n",
      "Epoch: 313 Total_Loss: 0.253507 Total_ACC: 0.923400\n"
     ]
    }
   ],
   "source": [
    "# 5.评价模型的性能\n",
    "def test(model, batch_size=32):\n",
    "    test_loader = DataLoader(test_datasets, batch_size=batch_size, shuffle=False)\n",
    "    \n",
    "    model.eval()      # 将模型转换为测试状态\n",
    "    total_loss = 0\n",
    "    total_acc = 0\n",
    "    test_epoch = 0 \n",
    "    for data in test_loader:\n",
    "        eval_loss = 0\n",
    "        eval_acc = 0\n",
    "        img, label = data      # 获取测试数据\n",
    "        img = img[:,0]\n",
    "    #     print(img.shape)\n",
    "        # 由于测试状态下不需方向传播，所以可以释放缓存\n",
    "        with torch.no_grad():\n",
    "\n",
    "            img, label = img.to(device), label.to(device)\n",
    "            out = model(img)     # 计算图像的标签 [img.size(0), 10]\n",
    "            loss = criterion(out, label)\n",
    "            eval_loss += loss.data* label.size(0)   # 计算该批次的总损失\n",
    "            _, pred = torch.max(out, 1)          # 在一行内按列比大小得[64,1],tenso为[64]\n",
    "        #     print(_, pred.shape)\n",
    "            num_correct = (pred == label).sum()\n",
    "            eval_acc += num_correct.data\n",
    "        #     print(eval_acc)    \n",
    "            total_loss += eval_loss    # 累计所有批次数据的损失和准确率\n",
    "            total_acc  += eval_acc\n",
    "            if (test_epoch + 1) % 10 == 0:\n",
    "                batch_loss  = (eval_loss / img.size(0))        # 计算该批次的损失\n",
    "                batch_acc   = (eval_acc.float() / img.size(0)) # 计算该批次的准确率\n",
    "                print('Epoch: {} Test Loss: {:.6f}, ACC: {:.6f}'.format(test_epoch+1, batch_loss, batch_acc))\n",
    "            test_epoch += 1\n",
    "    print('----------Test Done!----------')\n",
    "    print('Epoch: {} Total_Loss: {:.6f} Total_ACC: {:.6f}'.format(\\\n",
    "          test_epoch, total_loss/len(test_datasets), float(total_acc)/len(test_datasets)))\n",
    "save_model = torch.load('./model/rnn_1000.pth')\n",
    "save_model.to(device)\n",
    "test(save_model)         # 评估模型性能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 预测时间序列(回归)\n",
    "循环神经网络具有记忆单元，所以可以预测时间序列\n",
    "\n",
    "这里使用sin曲线预测cos曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.设定超参数 \n",
    "time_step = 10     # rnn的时间步长，即seq长度\n",
    "input_size = 1     # rnn的输入维度\n",
    "lr = 1e-2          # 学习率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ff8db8c3c8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "# 2.显示数据，绘制sin和cos曲线\n",
    "def show():\n",
    "    x = np.linspace(0, np.pi*2, 100, dtype=np.float32)  # 定义横轴的100个数据\n",
    "    y_sin = np.sin(x)     # 计算纵轴的数据\n",
    "    y_cos = np.cos(x)\n",
    "    plt.plot(x, y_sin, 'r-', label='input (sinx)')\n",
    "    plt.plot(x, y_cos, 'b-', label='target (cosx)')\n",
    "    plt.legend(loc='best')\n",
    "    plt.show()\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.定义网络\n",
    "class RNN(nn.Module):\n",
    "    def __init__(self, in_dim, hidden_dim, out_dim=1):\n",
    "        super().__init__()\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.out_dim = out_dim\n",
    "        self.rnn = nn.RNN(\n",
    "            input_size=in_dim,          # 网络的输入维度为1\n",
    "            hidden_size= hidden_dim,    # 隐藏单元的特征数(维度)\n",
    "            num_layers = 1,             # 网络层数\n",
    "            batch_first = True          # (batch, time_step, input_size)\n",
    "        )\n",
    "        self.dense = nn.Linear(hidden_dim, out_dim)  # 网络输出维度也是1 \n",
    "    \n",
    "    def forward(self, x, h_state):\n",
    "        # x: (batch, time_step, in_dim)\n",
    "        # rnn_out: (batch, time_step, hidden_dim*1)  time_step即seq长度\n",
    "        # h_state: (num_layers*1, batch, hidden_dim)\n",
    "        \n",
    "        # rnn_out是time_step上的整个输出，即seq序列上的整个输出\n",
    "        # 而这里的 h_state却是最后一个时间点(seq序列的最后一个)的输出\n",
    "        rnn_out, h_state = self.rnn(x, h_state)\n",
    "#         print(rnn_out.size(), h_state.shape)  # torch.Size([1, 10, 6]) torch.Size([1, 1, 6])\n",
    "        \n",
    "        # 保存所有时间点的预测值\n",
    "        total_out = []\n",
    "        for step in range(rnn_out.size(1)):   # 按照time_step访问数据\n",
    "            step_out = rnn_out[:, step, :]    # 获取当前time的输出 [batch, hidden]\n",
    "            dense_out = self.dense(step_out)  # 通过全连接获得当前输出值 [batch, 1]\n",
    "            total_out.append(dense_out)\n",
    "#         print(total_out)\n",
    "        out = torch.stack(total_out, dim=1)   # 第2维度叠加 [batch, time_step, in_dim]\n",
    "#         print(out.shape)\n",
    "        return out, h_state\n",
    "    \n",
    "#     # 使用向量化的方式来代替循环，提高计算效率\n",
    "#     def forward(self, x, h_state):\n",
    "#         rnn_out, h_state = self.rnn(x, h_state) \n",
    "# #       print(rnn_out.shape, h_state.shape)\n",
    "#         rnn_out_reshaped = torch.reshape(rnn_out, [-1, self.hidden_dim]) # get [*,hidden]\n",
    "# #       print(rnn_out_reshaped.shape)\n",
    "# #       rnn_out_reshaped = rnn_out.view(-1, self.hidden_dim)    # there is a bug!!!!!\n",
    "       \n",
    "#         dense_out = self.dense(rnn_out_reshaped)                # get [*,1]\n",
    "#         final_out = dense_out.view(-1, time_step, self.out_dim) # get [batch, tim_step, out_dim]\n",
    "#         return final_out, h_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: Qt5Agg\n",
      "Epoch 100 loss 0.0009\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ff8dbf62b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib\n",
    "# 4.定义损失函数、优化函数\n",
    "rnn = RNN(in_dim=1, hidden_dim=6)                # 创建RNN模型\n",
    "criterion = nn.MSELoss()                         # 回归任务，使用均方差损失\n",
    "optimizer = optim.Adam(rnn.parameters(), lr=lr)  # Adam优化\n",
    "epochs = 100                                     # 使用数据训练几轮\n",
    "h_state = None                                   # 开始的状态h_0设置为0\n",
    "\n",
    "plt.figure(1, figsize=(12, 5))\n",
    "plt.ion()\n",
    "# 训练模型\n",
    "def train(model):\n",
    "    global h_state\n",
    "    for epoch in range(epochs):\n",
    "        start, end = map(lambda x:x*np.pi, [epoch, epoch+1])   # [n*pi, (n+1)*pi]\n",
    "        steps = np.linspace(start, end, time_step, dtype=np.float32)  # 取10个数据\n",
    "        x_np = np.sin(steps)   # 这里用sinx预测cosx\n",
    "        y_np = np.cos(steps)\n",
    "        \n",
    "        # 将数据转换到rnn可输入的维度\n",
    "        # 定义函数扩展维度，并转换为tensor\n",
    "        unsqueeze = lambda x: torch.from_numpy(x[np.newaxis, :, np.newaxis])\n",
    "        x, y = map(unsqueeze, [x_np, y_np])   # 扩展x,y维度 [batch, time_step, in_dim]      \n",
    "        \n",
    "        # rnn 对于每个 step 的 prediction, 还有最后一个 step 的 h_state\n",
    "        prediction , h_state= model(x, h_state)\n",
    "        # 该步骤很重要，重新包装隐藏状态，断开与上次迭代的连接，将本次产生的\n",
    "        # h_state数据留到下一个时刻使用!!!\n",
    "        h_state = h_state.data \n",
    "        \n",
    "        loss = criterion(prediction, y)      \n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        # 弹出窗口显示动态图\n",
    "        plt.plot(steps, y_np.flatten(), 'r-')\n",
    "        plt.plot(steps, prediction.data.numpy().flatten(), 'b-')\n",
    "        plt.draw(); plt.pause(0.05)\n",
    "    print('Epoch {} loss {:.4f}'.format(epoch+1, loss.item()))          \n",
    "    plt.ioff()\n",
    "    plt.show()\n",
    "                       \n",
    "train(rnn)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "小结:\n",
    "- jupyter中显示动态图的方法\n",
    "```python\n",
    "%matplotlib inline\n",
    "from IPython import display\n",
    "display.clear_output(wait=True)\n",
    "```\n",
    "经过“画图=>清理=>画图”循环来动态显示图片\n",
    "- 在RNN做分类时，不同批次的数据是不联系的，所以不需要保存该批次的`hidden_state`，但在RNN做回归时，整个训练集是时间序列，所以按顺序进行训练的批次是有关系的，需要保存上一批次的`hidden_state`，其中`h_state = h_state.data`一句把上一次的状态保存以备下次使用 "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
